Hoe maak ik 'git add' ongedaan voordat ik vastleg?

1
2
De volgende
Je kunt git add ongedaan maken voordat je commit met
git reset 
die het zal verwijderen uit de huidige index (de "op het punt staan ​​vast te leggen" lijst) zonder iets anders te veranderen.
Je kunt gebruiken
git reset
zonder enige bestandsnaam om alle geplande wijzigingen ongedaan te maken. Dit kan handig zijn als er te veel bestanden zijn om binnen een redelijke tijd een voor een op te nemen.
In oude versies van Git zijn de bovenstaande commando's equivalent aan respectievelijk git reset HEAD  en git reset HEAD, en zullen mislukken als HEAD niet gedefinieerd is (omdat je nog geen commits hebt gemaakt in je repository) of dubbelzinnig (omdat je creëerde een branch genaamd HEAD, wat een stom ding is dat je niet zou moeten doen). Dit is echter veranderd in Git 1.8.2, dus in moderne versies van Git kun je de bovenstaande commando's gebruiken, zelfs voordat je je eerste commit maakt:
"git reset" (zonder opties of parameters) gebruikt om een ​​foutmelding te geven wanneer
je hebt geen commits in je geschiedenis, maar het geeft je nu
een lege index (om overeen te komen met een niet-bestaande commit waar je niet eens op zit).
Documentatie: git reset
|
Jij wil:
git rm --cached 
Redenering:
Toen ik dit nieuw was, heb ik het eerst geprobeerd
git reset.
(om mijn hele eerste toevoeging ongedaan te maken), alleen om dit (niet zo) nuttige bericht te krijgen:
fataal: 'HEAD' kon niet worden omgezet als een geldige referentie.
Het blijkt dat dit komt doordat de HEAD ref (branch?) Pas bestaat na de eerste commit. Dat wil zeggen, je zult hetzelfde beginnersprobleem tegenkomen als ik als je workflow, net als de mijne, zoiets was als:
cd naar mijn geweldige nieuwe projectdirectory om Git, de nieuwe hotness, uit te proberen
git init
git add.
git status
... veel onzin scrollt voorbij ...
=> Verdomme, ik wilde dat allemaal niet toevoegen.
google "git add ongedaan maken"
=> vind Stack Overflow - ja
git reset.
=> fataal: 'HEAD' kon niet worden omgezet als een geldige referentie.
Het blijkt verder dat er in de mailinglijst een bug is gelogd tegen de nutteloosheid hiervan.
En dat de juiste oplossing daar was in de Git-statusuitvoer (die, ja, ik verdoezelde als 'onzin)
...
# Veranderingen die moeten worden vastgelegd:
# (gebruik "git rm --cached  ..." om te unstagen)
...
En de oplossing is inderdaad om git rm --cached FILE te gebruiken.
Let op de waarschuwingen elders hier - git rm verwijdert je lokale werkkopie van het bestand, maar niet als je --cached gebruikt. Hier is het resultaat van git help rm:
- in de cache
Gebruik deze optie om alleen paden uit de index te unstagen en te verwijderen.
Werkboombestanden, al dan niet gewijzigd, blijven staan.
Ik ga verder met gebruiken
git rm --cached.
om alles te verwijderen en opnieuw te beginnen. Het werkte echter niet, want tijdens het toevoegen. recursief is, blijkt dat rm -r nodig heeft om te recurseren. Zucht.
git rm -r --cached.
Oké, nu ben ik terug bij waar ik begon. De volgende keer ga ik -n gebruiken om een ​​test uit te voeren en te kijken wat er zal worden toegevoegd:
git add -n.
Ik ritste alles op een veilige plaats voordat ik git help rm vertrouwde over de --cached die niets vernietigde (en wat als ik het verkeerd heb gespeld).
|
Als je typt:
git status
Git zal je vertellen wat er geënsceneerd wordt, etc., inclusief instructies voor het unstagen:
gebruik "git reset HEAD  ..." om te unstagen
Ik vind dat Git me redelijk goed aanspoort om het juiste te doen in situaties als deze.
Opmerking: recente Git-versies (1.8.4.x) hebben dit bericht gewijzigd:
(gebruik "git rm --cached  ..." om te unstagen)
|
Ter verduidelijking: git add verplaatst wijzigingen van de huidige werkdirectory naar het staging-gebied (index).
Dit proces wordt enscenering genoemd. Dus de meest natuurlijke opdracht om de wijzigingen (gewijzigde bestanden) te faseren is de voor de hand liggende:
git stage
git add is gewoon een gemakkelijker te typen alias voor git stage
Jammer dat er geen git unstage- of git unadd-opdrachten zijn. De relevante is moeilijker te raden of te onthouden, maar het is vrij duidelijk:
git reset HEAD -
Hiervoor kunnen we eenvoudig een alias aanmaken:
git config --global alias.unadd 'reset HEAD -'
git config --global alias.unstage 'reset HEAD -'
En tot slot hebben we nieuwe commando's:
git add file1
git stage-bestand 2
git unadd-bestand2
git unstage-bestand1
Persoonlijk gebruik ik nog kortere aliassen:
git a # Voor enscenering
git u # Voor unstaging
|
Een toevoeging aan het geaccepteerde antwoord, als je per ongeluk toegevoegde bestand enorm was, zul je waarschijnlijk opmerken dat, zelfs nadat je het uit de index hebt verwijderd met 'git reset', het nog steeds ruimte lijkt in te nemen in de .git-directory.
Dit is niets om je zorgen over te maken; het bestand staat inderdaad nog in de repository, maar alleen als een "los object". Het zal niet naar andere repositories worden gekopieerd (via kloon, push), en de ruimte zal uiteindelijk worden teruggevorderd - hoewel misschien niet erg snel. Als je angstig bent, kun je rennen:
git gc --prune = nu
Update (wat volgt is mijn poging om enige verwarring weg te nemen die kan ontstaan ​​door de meest up-gestemde antwoorden):
Dus, wat is het echte ongedaan maken van git add?
git reset HEAD ?
of
git rm --cached ?
Strikt genomen, en als ik me niet vergis: geen.
git add kan niet ongedaan worden gemaakt - in het algemeen veilig.
Laten we eerst herinneren wat git add  eigenlijk doet:
Als  niet eerder werd gevolgd, voegt git add het toe aande cache, met zijn huidige inhoud.
Als  al werd gevolgd, slaat git add de huidige inhoud (snapshot, versie) op in de cache. In Git wordt deze actie nog steeds add genoemd (niet louter updaten), omdat twee verschillende versies (snapshots) van een bestand als twee verschillende items worden beschouwd: daarom voegen we inderdaad een nieuw item toe aan de cache, om uiteindelijk later gepleegd.
In het licht hiervan is de vraag enigszins dubbelzinnig:
Ik heb per ongeluk bestanden toegevoegd met de opdracht ...
Het scenario van het OP lijkt het eerste te zijn (niet-bijgehouden bestand), we willen dat de "ongedaan maken" het bestand (niet alleen de huidige inhoud) uit de bijgehouden items verwijdert. Als dit het geval is, dan is het oké om git rm --cached  uit te voeren.
En we zouden ook git reset HEAD  kunnen uitvoeren. Dit heeft in het algemeen de voorkeur, omdat het in beide scenario's werkt: het maakt ook het ongedaan maken wanneer we ten onrechte een versie van een reeds bijgehouden item hebben toegevoegd.
Maar er zijn twee kanttekeningen.
Ten eerste: er is (zoals aangegeven in het antwoord) slechts één scenario waarin git reset HEAD niet werkt, maar git rm --cached wel: een nieuwe repository (geen commits). Maar eigenlijk is dit een praktisch irrelevant geval.
Ten tweede: Wees je ervan bewust dat git reset HEAD de eerder gecachte bestandsinhoud niet op magische wijze kan herstellen, het synchroniseert het gewoon opnieuw vanaf de HEAD. Als onze misleide git add een vorige geënsceneerde niet-gecommitteerde versie overschreef, kunnen we deze niet herstellen. Daarom kunnen we strikt genomen [*] niet ongedaan maken.
Voorbeeld:
$ git init
$ echo "versie 1"> bestand.txt
$ git add file.txt # Voeg eerst file.txt toe
$ git commit -m 'eerste commit'
$ echo "versie 2"> bestand.txt
$ git add file.txt # Stage (niet vastleggen) "versie 2" van file.txt
$ git diff --cached file.txt
-versie 1
+ versie 2
$ echo "versie 3"> bestand.txt
$ git diff bestand.txt
-versie 2
+ versie 3
$ git add file.txt # Oeps, we bedoelden dit niet
$ git reset HEAD file.txt # Ongedaan maken?
$ git diff --cached file.txt # Geen dif, natuurlijk. stage == HEAD
$ git diff file.txt # We hebben "versie 2" onherroepelijk verloren
-versie 1
+ versie 3
Dit is natuurlijk niet erg kritiek als we gewoon de gebruikelijke luie workflow volgen van 'git add' alleen doen voor het toevoegen van nieuwe bestanden (geval 1), en we updaten nieuwe inhoud via het commit, git commit -a commando.
* (Bewerken: het bovenstaande is praktisch correct, maar er kunnen toch enkele enigszins hackachtige / ingewikkelde manieren zijn om wijzigingen te herstellen die waren geënsceneerd, maar niet vastgelegd en vervolgens overschreven - zie de opmerkingen van Johannes Matokic en iolsmit)
|
Het ongedaan maken van een bestand dat al is toegevoegd, is vrij eenvoudig met Git. Voor het resetten van myfile.txt, die al zijn toegevoegd, gebruik je:
git reset HEAD myfile.txt
Uitleg:
Nadat je ongewenste bestanden hebt gestaged, kun je dit ongedaan maken git reset. Head is de kop van uw bestand in de lokale taal en de laatste parameter is de naam van uw bestand.
Ik heb de stappen in de onderstaande afbeelding in meer details voor je gemaakt, inclusief alle stappen die in deze gevallen kunnen gebeuren:
|
git rm --cached. -r
zal alles wat je hebt toegevoegd recursief "ongedaan maken" uit je huidige directory
|
Rennen
git gui
en verwijder alle bestanden handmatig of door ze allemaal te selecteren en op de knop unstage from commit te klikken.
|
De vraag is niet duidelijk gesteld. De reden is dat git add twee betekenissen heeft:
het toevoegen van een nieuw bestand aan het staging-gebied, en vervolgens ongedaan maken met git rm --cached bestand.
het toevoegen van een gewijzigd bestand aan het staging-gebied, en vervolgens ongedaan maken met git reset HEAD file.
Gebruik bij twijfel
git reset HEAD-bestand
Omdat het in beide gevallen het verwachte doet.
Waarschuwing: als je git rm --cached bestand doet in een bestand dat is gewijzigd (een bestand dat eerder in de repository bestond), dan zal het bestand worden verwijderd bij git commit! Het zal nog steeds bestaan ​​in je bestandssysteem, maar als iemand anders je commit trekt, zal het bestand uit hun werkboom verwijderd worden.
git status zal je vertellen of het bestand een nieuw bestand was of gewijzigd:
Op filiaalmeester
Veranderingen die moeten worden vastgelegd:
(gebruik "git reset HEAD  ..." om te unstagen)
nieuw bestand: my_new_file.txt
gewijzigd: my_modified_file.txt
|
Git heeft commando's voor elke denkbare actie, maar het heeft uitgebreide kennis nodig om dingen goed te krijgen en daarom is het op zijn best contra-intuïtief ...
Wat je eerder deed:
Een bestand gewijzigd en git add. Gebruikt, of git add .
Wat je wilt:
Verwijder het bestand uit de index, maar bewaar het versiebeheer en laat niet-vastgelegde wijzigingen in de werkkopie achter:
git reset HEAD 
Reset het bestand naar de laatste staat van HEAD, maak wijzigingen ongedaan en verwijder ze uit de index:
# Denk aan `svn revert ` IIRC.
git reset HEAD 
git checkout 
# Als je een `` hebt met de naam ``, gebruik dan:
git checkout - 
Dit is nodig omdat git reset --hard HEAD niet zal werken met enkele bestanden.
Verwijder  uit index en versiebeheer, waarbij het niet-versienummer bestand met wijzigingen in de werkkopie behouden blijft:
git rm --cached 
Verwijder  volledig uit werkkopie en versiebeheer:
git rm 
|
Als je je eerste commit hebt en je kunt gitreset, verklaar gewoon "Git faillissement" en verwijder de .git-map en begin opnieuw
|
Zoals bij veel van de andere antwoorden, kun je git reset gebruiken
MAAR:
Ik vond dit geweldige kleine bericht dat eigenlijk het Git-commando (nou ja, een alias) toevoegt voor git unadd: zie git unadd voor details of ..
Gewoon,
git config --global alias.unadd "reset HEAD"
Nu kan je
git unadd foo.txt bar.txt
|
Gebruik git add -i om zojuist toegevoegde bestanden uit je aanstaande commit te verwijderen. Voorbeeld:
Het bestand toevoegen dat u niet wilde:
$ git add foo
$ git status
# Op filiaal-master
# Veranderingen die moeten worden vastgelegd:
# (gebruik "git reset HEAD  ..." om te unstagen)
#
# nieuw bestand: foo
#
# Niet-bijgehouden bestanden:
# (gebruik "git add  ..." om op te nemen in wat zal worden vastgelegd)
# [...] #
Naar interactieve add gaan om je add ongedaan te maken (de commando's die hier bij git zijn getypt zijn "r" (revert), "1" (eerste item in de lijst revert shows), 'return' om uit de revert-modus te vallen en "q" (stoppen):
$ git add -i
geënsceneerd unstaged pad
1: + 1 / -0 niets foo
*** Commando's ***
1: [s] tatus 2: [u] pdate 3: [r] evert 4: [a] dd untracked
5: [p] atch 6: [d] iff 7: [q] uit 8: [h] elp
Wat nu> r
geënsceneerd unstaged pad
1: + 1 / -0 niets [f] oo
Terugzetten >> 1
geënsceneerd unstaged pad
* 1: + 1 / -0 niets [f] oo
Terugzetten >>
opmerking: foo wordt nu niet gevolgd.
één pad teruggedraaid
*** Commando's ***
1: [s] tatus 2: [u] pdate 3: [r] evert 4: [a] dd untracked
5: [p] atch 6: [d] iff 7: [q] uit 8: [h] elp
Wat nu> q
Doei.
$
Dat is het! Hier is uw bewijs, waaruit blijkt dat "foo" weer op de niet-bijgehouden lijst staat:
$ git status
# Op filiaal-master
# Niet-bijgehouden bestanden:
# (gebruik "git add  ..." om op te nemen in wat zal worden vastgelegd)
# [...]
# foo
niets toegevoegd om vast te leggen, maar niet-gevolgde bestanden aanwezig (gebruik "git add" om te volgen)
$
|
git remove of git rm kan hiervoor worden gebruikt, met de --cached vlag. Proberen:
git help rm
|
Hier is een manier om dit vervelende probleem te vermijden wanneer u een nieuw project start:
Maak de hoofddirectory voor uw nieuwe project.
Voer git init uit.
Maak nu een .gitignore-bestand (zelfs als het leeg is).
Leg uw .gitignore-bestand vast.
Git maakt het erg moeilijk om git reset uit te voeren als je geen commits hebt. Als je een kleine initiële commit aanmaakt om er een te hebben, daarna kun je git add -A en git reset zo vaak als je wilt om alles goed te krijgen.
Een ander voordeel van deze methode is dat als u later problemen met het einde van de regel tegenkomt en al uw bestanden moet vernieuwen, het eenvoudig is:
Bekijk die eerste commit. Hiermee worden al uw bestanden verwijderd.
Bekijk dan nogmaals je meest recente commit. Hiermee worden nieuwe kopieën van uw bestanden opgehaald met uw huidige instellingen voor het einde van de regel.
|
Misschien is Git geëvolueerd sinds je je vraag hebt gepost.
$> git --version
git versie 1.6.2.1
Nu kunt u proberen:
git reset HEAD.
Dit zou moeten zijn wat u zoekt.
|
Merk op dat als u geen revisie opgeeft, u een scheidingsteken moet opnemen. Voorbeeld van mijn console:
git reset 
fataal: dubbelzinnig argument '': onbekende revisie of pad niet in de werkende boom.
Gebruik '-' om paden van revisies te scheiden
git reset - 
Niet-getrapte wijzigingen na reset:
M 
(Git-versie 1.7.5.4)
|
Om nieuwe bestanden uit het staging-gebied te verwijderen (en alleen in het geval van een nieuw bestand), zoals hierboven voorgesteld:
git rm --cached FILE
Gebruik rm --cached alleen voor nieuwe bestanden die per ongeluk zijn toegevoegd.
|
Om elk bestand in een bepaalde map (en zijn submappen) opnieuw in te stellen, kunt u de volgende opdracht gebruiken:
git reset *
|
Gebruik het * commando om meerdere bestanden tegelijk af te handelen:
git reset HEAD * .prj
git reset HEAD * .bmp
git reset HEAD * gdb *
enzovoort.
|
Typ gewoon git reset, het zal terugkeren en het is alsof je nooit git add hebt getypt. sinds je laatste commit. Zorg ervoor dat u zich eerder heeft gecommitteerd.
|
Stel dat ik een nieuw bestand maak, newFile.txt:
Stel dat ik het bestand per ongeluk toevoeg, git add newFile.txt:
Nu wil ik deze add ongedaan maken, voordat ik vastleg, git reset newFile.txt:
|
Voor een specifiek bestand:
git reset mijn_bestand.txt
git checkout my_file.txt
Voor alle toegevoegde bestanden:
git reset.
git checkout.
Opmerking: afrekenen verandert de code in de bestanden en gaat naar de laatst bijgewerkte (vastgelegde) status. reset verandert de codes niet; het reset gewoon de header.
|
Om git add ongedaan te maken, gebruik je:
git reset bestandsnaam
|
Met deze opdracht worden uw wijzigingen ongedaan gemaakt:
git reset HEAD bestandsnaam.txt
Je kan ook gebruiken
git add -p
om delen van bestanden toe te voegen.
|
Er is ook een interactieve modus:
git add -i
Kies optie 3 om het toevoegen van bestanden ongedaan te maken. In mijn geval wil ik vaak meer dan één bestand toevoegen, en in de interactieve modus kun je dit soort nummers gebruiken om bestanden toe te voegen. Hiervoor zijn alles behalve 4: 1, 2, 3 en 5 nodig
Om een ​​reeks te kiezen, typ je 1-5 om alles van 1 tot 5 te nemen.
Git-staging-bestanden
|
git add myfile.txt # Dit zal je bestand toevoegen aan de to-be-commit lijst
Helemaal het tegenovergestelde van dit commando is:
git reset HEAD myfile.txt # Dit zal ongedaan makenhet.
dus je bevindt je in de vorige staat. Opgegeven staat weer in de niet-bijgehouden lijst (vorige staat).
Het zal je hoofd resetten met dat gespecificeerde bestand. dus als je hoofd het niet heeft, zal het het gewoon resetten.
|
git reset bestandsnaam.txt
Verwijdert een bestand met de naam filename.txt uit de huidige index, het gebied "op het punt te worden vastgelegd", zonder iets anders te veranderen.
|
git reset bestandsnaam.txt
Verwijdert een bestand met de naam filename.txt uit de huidige index, het gebied "op het punt te worden vastgelegd", zonder iets anders te veranderen.
|
In Sourcetree doe je dit eenvoudig via de GUI.
U kunt controleren welk commando Sourcetree gebruikt om een ​​bestand te unstagen.
Ik heb een nieuw bestand gemaakt en het aan Git toegevoegd. Daarna heb ik het unstaged met behulp van de Sourcetree GUI.
Dit is het resultaat:
Bestanden ongedaan maken [08/12/15 10:43]
git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - pad / naar / bestand / bestandsnaam.java
Sourcetree gebruikt reset om nieuwe bestanden te unstage.
|
1
2
De volgende
Zeer actieve vraag. Verdien 10 reputatie om deze vraag te beantwoorden. De reputatievereiste helpt deze vraag te beschermen tegen spam en niet-beantwoording.
Niet het antwoord waar je naar zoekt? Blader door andere vragen met de tag git version-control git-commit git-stage of stel je eigen vraag.